package com.example.dmweb.chat;

import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
//import net.sourceforge.tess4j.ITesseract;
//import net.sourceforge.tess4j.Tesseract;
//import net.sourceforge.tess4j.TesseractException;
//import org.opencv.imgcodecs.Imgcodecs;
import org.springframework.web.bind.annotation.*;
//import org.opencv.core.*;
//import org.opencv.imgproc.Imgproc;
import java.io.File;
import java.util.*;


@RestController
@RequestMapping("/energy")
@CrossOrigin
@Api(value = "能源专家", tags = {"能源专家"})
@Slf4j
public class ChatController {
    //    @Value("${upload.path}")
    private String uploadPath = "C:\\Users\\29634\\Desktop\\ceshidddd\\";
    private String datapath = "D:\\work\\JetBrains\\project\\virtualPowerPlant\\CSPG_VPP\\vpp-web\\src\\main\\resources\\file";

//    public static void main(String[] args) throws TesseractException {
////        log.info("结果：{}",ocr(new File("C:\\Users\\29634\\Desktop\\xxxxxxx.jpg")));
//        ocr2();
//    }
//    public static void ocr2() {
//        // 设置Tesseract
//        ITesseract tesseract = new Tesseract();
//        tesseract.setDatapath("D:/work/JetBrains/project/virtualPowerPlant/CSPG_VPP/vpp-web/src/main/resources/file");
//        tesseract.setLanguage("chi_sim");
//
//        // 加载OpenCV库
//        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
//
//        // 读取表格图片
//        Mat image = Imgcodecs.imread("C:\\Users\\29634\\Desktop\\xxxxxxx.jpg");
//
//        // 进行图像处理，确保得到二值化图像
//        Mat grayImage = new Mat();
//        Imgproc.cvtColor(image, grayImage, Imgproc.COLOR_BGR2GRAY);
//        Imgproc.threshold(grayImage, grayImage, 0, 255, Imgproc.THRESH_BINARY_INV + Imgproc.THRESH_OTSU);
//
//        // 查找表格轮廓
//        Mat hierarchy = new Mat();
//        List<MatOfPoint> contours = new ArrayList<>();
//        Imgproc.findContours(grayImage, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
//
//        // 对每个表格轮廓进行处理
//        for (int i = 0; i < contours.size(); i++) {
//            // 提取当前表格的边界框
//            Rect rect = Imgproc.boundingRect(contours.get(i));
//
//            // 提取当前表格的图像
//            Mat table = new Mat(image, rect);
//
//            // 将表格图像保存为临时文件
//            String tempImagePath = "temp_table_" + i + ".jpg";
//            Imgcodecs.imwrite(tempImagePath, table);
//
//            try {
//                // 使用Tesseract识别表格内容
//                String result = tesseract.doOCR(new File(tempImagePath));
//                System.out.println("Table " + (i + 1) + " OCR Result:");
//                System.out.println(result);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            // 删除临时文件
//            new File(tempImagePath).delete();
//        }
//    }
//    public static String ocr(File file) throws TesseractException {
//        String uploadPath = "C:\\Users\\29634\\Desktop\\ceshidddd\\";
//
//        // 检查上传目录是否存在，如果不存在则创建
//        File uploadDir = new File(uploadPath);
//        if (!uploadDir.exists()) {
//            uploadDir.mkdirs();
//        }
//        String fileName = file.getName();
//        File uploadFile = new File("zzz"+uploadPath + fileName);
//        file.renameTo(uploadFile);
//        // 对图像进行预处理
//        Mat preprocessedImage = preprocessImage(file);
////        Mat src1 = correctImage(Imgcodecs.imread(uploadFile.getAbsolutePath()));
////        Imgcodecs.imwrite("C:\\Users\\29634\\Desktop\\ceshidddd\\" + "corrected_image.jpg", src1);
//        // 保存预处理后的图像
//        String preprocessedImagePath = uploadPath + "111" +fileName;
//        Imgcodecs.imwrite(preprocessedImagePath, preprocessedImage);
//
//        Tesseract tesseract = new Tesseract();
//        tesseract.setDatapath("D:/work/JetBrains/project/virtualPowerPlant/CSPG_VPP/vpp-web/src/main/resources/file");
//        tesseract.setLanguage("chi_sim");
//
//        String result = tesseract.doOCR(new File(preprocessedImagePath));
//        return result;
//    }
//    private static Mat preprocessImage(File imageFile) {
//        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
//        // 读取图像文件
//        Mat src = Imgcodecs.imread(imageFile.getAbsolutePath(), Imgcodecs.IMREAD_GRAYSCALE);
//
//        if (src.empty()) {
//            System.err.println("无法读取图像文件：" + imageFile.getAbsolutePath());
//            return null;
//        }
//
//        // 反转颜色
//        Core.bitwise_not(src, src);
//        // 应用阈值化来只保留白色部分
//        Mat whiteOnly = new Mat();
//        Imgproc.threshold(src, whiteOnly, 200, 255, Imgproc.THRESH_BINARY);
//
//        // 创建与源图像相同大小的全白图像
//        Mat whiteMask = Mat.ones(src.size(), CvType.CV_8UC1);
//        whiteMask.setTo(new Scalar(255));
//
//        // 创建与源图像相同大小的全黑图像
//        Mat blackMask = Mat.zeros(src.size(), CvType.CV_8UC1);
//
//        // 将源图像拷贝到两个新的临时图像中
//        Mat temp1 = new Mat();
//        Mat temp2 = new Mat();
//        src.copyTo(temp1);
//        src.copyTo(temp2);
//
//        // 在全白图像中，将黑色部分设置为黑色
//        Core.bitwise_and(temp1, whiteMask, temp1);
//
//        // 在全黑图像中，将白色部分设置为白色
//        Core.bitwise_and(temp2, blackMask, temp2);
//
//        // 将两个结果图像进行合并
//        Core.bitwise_or(temp1, temp2, src);
//
//        // 阈值化操作
//        Imgproc.threshold(src, src, 115, 255, Imgproc.THRESH_BINARY);
//
//
//        // 自适应阈值化处理图像，灰度化，二值化
//        Mat binarized = new Mat();
//        Imgproc.adaptiveThreshold(src, binarized, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, -2);
//
//
//        // 去除水平线
//        Mat horizontal = src.clone();
//        int horizontalSize = horizontal.cols() / 30;
//        Mat horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontalSize, 1));
//        Imgproc.erode(horizontal, horizontal, horizontalStructure, new Point(-1, -1));
//        Imgproc.dilate(horizontal, horizontal, horizontalStructure, new Point(-1, -1));
//
//        // 去除垂直线
//        Mat vertical = src.clone();
//        int verticalSize = vertical.rows() / 30;
//        Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(1, verticalSize));
//        Imgproc.erode(vertical, vertical, verticalStructure, new Point(-1, -1));
//        Imgproc.dilate(vertical, vertical, verticalStructure, new Point(-1, -1));
//
//
//        // 合并图像以去除所有线条
//        Mat lines = new Mat();
//        Core.add(horizontal, vertical, lines);
//        Core.bitwise_not(lines, lines);
//        Core.bitwise_and(src, lines, src);
//
//        // 清理边界
//        int borderWidth = 5;
//        Rect roi = new Rect(new Point(borderWidth, borderWidth), new Size(binarized.cols() - 2 * borderWidth, binarized.rows() - 2 * borderWidth));
//        Mat cleaned = new Mat(src, roi);
////        Core.bitwise_not(cleaned, cleaned);
//        Imgcodecs.imwrite("C:\\Users\\29634\\Desktop\\ceshidddd\\" + "huiduhou00000.jpg", src);
//        Imgcodecs.imwrite("C:\\Users\\29634\\Desktop\\ceshidddd\\" + "huiduhou00000.jpg", cleaned);
//
//        return cleaned;
//    }
//    public static Mat correctImage(Mat img) {
//        // 图像预处理：边缘检测
//        Mat imgGray = new Mat();
//        Imgproc.cvtColor(img, imgGray, Imgproc.COLOR_BGR2GRAY);
//        Mat imgBlur = new Mat();
//        Imgproc.GaussianBlur(imgGray, imgBlur, new Size(3, 3), 3, 0);
//        Mat imgCanny = new Mat();
//        Imgproc.Canny(imgBlur, imgCanny, 70, 90);
//
//        // 寻找轮廓
//        Mat hierarchy = new Mat();
//        MatOfPoint biggestContour = findBiggestContour(imgCanny, hierarchy);
//
//        if (biggestContour != null) {
//            // 提取最大轮廓的四个顶点并进行排序和修正
//            Point[] sortedPoints = sortAndCorrectPoints(biggestContour.toArray());
//
//            if (sortedPoints.length == 4) {
//                // 计算透视变换矩阵
//                Mat perspectiveMatrix = Imgproc.getPerspectiveTransform(
//                        new MatOfPoint2f(sortedPoints),
//                        new MatOfPoint2f(
//                                new Point(0, 0),
//                                new Point(img.cols(), 0),
//                                new Point(0, img.rows()),
//                                new Point(img.cols(), img.rows())
//                        )
//                );
//
//                // 应用透视变换
//                Mat correctedImage = new Mat();
//                Imgproc.warpPerspective(img, correctedImage, perspectiveMatrix, new Size(img.cols(), img.rows()));
//
//                return correctedImage;
//            }
//        }
//
//        // 如果没有找到有效的轮廓或顶点，则返回原始图像
//        return img.clone();
//    }
//
//    public static MatOfPoint findBiggestContour(Mat img, Mat hierarchy) {
//        List<MatOfPoint> contours = new ArrayList<>();
//        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
//        double maxArea = 0;
//        MatOfPoint biggestContour = null;
//        for (MatOfPoint contour : contours) {
//            double area = Imgproc.contourArea(contour);
//            if (area > maxArea) {
//                maxArea = area;
//                biggestContour = contour;
//            }
//        }
//        return biggestContour;
//    }
//
//    public static Point[] sortAndCorrectPoints(Point[] points) {
//        // 对四个顶点按照顺时针方向排序
//        Point[] sortedPoints = sortPointsClockwise(points);
//
//        // 进行顶点修正（如果需要的话）
//        // 这里可以根据具体需求进行顶点修正操作
//
//        return sortedPoints;
//    }
//
//    private static Point[] sortPointsClockwise(Point[] points) {
//        // 计算中心点
//        Point center = calculateCenter(points);
//
//        // 根据极角排序
//        Arrays.sort(points, (p1, p2) -> {
//            double angle1 = Math.atan2(p1.y - center.y, p1.x - center.x);
//            double angle2 = Math.atan2(p2.y - center.y, p2.x - center.x);
//            return Double.compare(angle1, angle2);
//        });
//
//        return points;
//    }
//
//    private static Point calculateCenter(Point[] points) {
//        double centerX = 0;
//        double centerY = 0;
//        for (Point point : points) {
//            centerX += point.x;
//            centerY += point.y;
//        }
//        centerX /= points.length;
//        centerY /= points.length;
//        return new Point(centerX, centerY);
//    }
}
